package com.fdb.efp.batch.service.impl.dw;

import java.io.File;
import java.util.List;
import java.util.Objects;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import com.fdb.basic.framework.core.constant.MonAlrmLvlEnums.MonAlrmLvlEnum;
import com.fdb.basic.framework.core.util.DateTool;
import com.fdb.basic.framework.core.util.SFTPUtil;
import com.fdb.efp.batch.common.constant.BdLoanConstant;
import com.fdb.efp.batch.service.facade.dw.BdCusInfoBatchCreateService;
import com.fdb.efp.cus.service.facade.CusIndivCreatesProInfoService;
import com.fdb.efp.cus.service.vo.CusIndivCreatesProInfoVO;
import com.fdb.efp.esb.service.bo.req.hj.ReqCusInfoBatchCreateBean;
import com.fdb.efp.esb.service.facade.hj.CusInfoBatchCreateService;
import com.fdb.efp.loan.service.facade.AccoutErroTempService;
import com.fdb.efp.loan.service.vo.AccoutErroTempVO;

/**
 * 
 * 批量建立互金客户
 * 
 * 
 * @author ludayong
 * @since 2019年5月20日 下午2:53:36
 * @version 1.0
 */
@Service("bdCusInfoBatchCreateService")
public class BdCusInfoBatchCreateServiceImpl implements BdCusInfoBatchCreateService {

	Logger logger = LoggerFactory.getLogger(BdCusInfoBatchCreateServiceImpl.class);

	// sftp用户名
	@Value("${analysis.hjUserName}")
	private String userName;

	// sftp密码
	@Value("${analysis.hjPassword}")
	private String password;

	// sftp主机ip
	@Value("${analysis.hjFtpHost}")
	private String ftpHost;

	// sftp主机端口
	@Value("${analysis.hjFtpPort}")
	private int ftpPort;

	// 迁移文件解析路径
	@Value("${analysis.baiduTranFilePath}")
	private String baiduTranFilePath;

	// 客户建档信息文件名
	@Value("${analysis.dataTransferCusFileName}")
	private String dataTransferCusFileName;

	// 分割符
	@Value("${analysis.dataTransferFileSeparation}")
	private String dataTransferFileSeparation;

	// 客户建档信息文件后缀名
	@Value("${analysis.dataTransferFileSuffix}")
	private String dataTransferFileSuffix;

	// 客户建档信息ok文件后缀名
	@Value("${analysis.dataTransferOkFileSuffix}")
	private String dataTransferOkFileSuffix;

	// 对内SFTP文件服务器：上传地址
	@Value("${analysis.remoteUpBaiduTransferFilePath}")
	private String remoteUpBaiduTransferFilePath;

	// 批量建立互金客户
	@Autowired
	@Qualifier("cusInfoBatchCreateService")
	private CusInfoBatchCreateService cusInfoBatchCreateService;

	// 客户建档结果过程信息
	@Autowired
	@Qualifier("cusIndivCreatesProInfoService")
	private CusIndivCreatesProInfoService cusIndivCreatesProInfoService;

	// 记录异常信息
	@Autowired
	@Qualifier("accoutErroTempService")
	private AccoutErroTempService accoutErroTempService;

	/**
	 * 
	 * 批量建立互金客户 <br>
	 * 0.1:ludayong:2019年5月20日 下午2:58:49:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年5月20日 下午2:58:49
	 * @date 2019年5月20日 下午2:58:49
	 * @version 0.1
	 */
	@Override
	public boolean downLoadFileNotice(String curDate) {
		boolean result = false;
		// 通知文件个数
		int noticeNum = 0;
		logger.info("批量客户建档解析开始，迁移文件路径：" + baiduTranFilePath);
		try {
			// 解析迁移文件路径
			String tranFilePath = baiduTranFilePath;
			logger.info("解析迁移文件路径：" + tranFilePath);
			// 解析文件
			File tranFile = new File(tranFilePath);
			// 如果文件存在
			if (tranFile.exists()) {
				// 客户建档文件
				String[] cusFileNames = dataTransferCusFileName.split(dataTransferFileSeparation);
				String cusFileName = "";
				if (!Objects.isNull(cusFileNames) && cusFileNames.length > 0) {
					for (String fileName : cusFileNames) {
						// 客户建档文件
						cusFileName = fileName + curDate + dataTransferFileSuffix;
						File cusFFile = new File(tranFilePath + cusFileName);
						// 客户建档文件存在
						if (cusFFile.exists()) {
							// 客户建档ok文件
							String cusOkFileName = cusFileName.replace(dataTransferFileSuffix, dataTransferOkFileSuffix);
							File okFile = new File(tranFilePath + cusOkFileName);
							// ok文件不存在
							if (!okFile.exists()) {
								return result;
							}
							// 上传客户建档信息到对内SFTP文件服务器
							boolean fileUploadResult = upFile(cusFileName);
							boolean fileOkUploadResult = false;
							if (fileUploadResult) {
								// ok文件存在
								if (okFile.exists()) {
									fileOkUploadResult = upFile(cusOkFileName);
								}
							}
							if (fileOkUploadResult) {
								logger.info("通知互金批量客户建档开始");
								// 批量客户建档信息
								ReqCusInfoBatchCreateBean reqCusInfoBatchCreateBean = new ReqCusInfoBatchCreateBean();
								// 文件名称
								reqCusInfoBatchCreateBean.setFileNm(cusFileName);
								boolean noticeRes = cusInfoBatchCreateService.downLoadFileNotice(reqCusInfoBatchCreateBean);
								if (noticeRes) {
									noticeNum++;
								} else {
									String tableName = "cus_indiv";
									String errorMsg = "通知互金批量客户建档失败";
									String remark = "通知互金批量客户建档失败，文件名：" + cusFileName;
									addErrorInfo(tableName, MonAlrmLvlEnum.SERIOUS.getEnname(), errorMsg, remark);
									logger.error(errorMsg);
								}
								logger.info("通知互金批量客户建档结束，通知结果[" + noticeRes + "]");
							}
						} else {
							continue;
						}
					}
				}
			}
			if (noticeNum > 0) {
				result = true;
			}
		} catch (Exception e) {
			e.printStackTrace();
			String tableInfo = "cus_indiv";
			String errorMsg = "批量客户建档解析出现异常";
			String remark = "批量客户建档解析出现异常，异常信息：" + e.getMessage();
			addErrorInfo(tableInfo, MonAlrmLvlEnum.SERIOUS.getEnname(), errorMsg, remark);
			logger.error(remark);
		}
		logger.info("批量客户建档解析结束，迁移文件路径：" + baiduTranFilePath + "，处理结果[" + result + "]");
		return result;
	}

	/**
	 * 
	 * 批量客户建档结果下载 <br>
	 * 0.1:ludayong:2019年5月20日 下午10:25:20:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年5月20日 下午10:25:20
	 * @date 2019年5月20日 下午10:25:20
	 * @version 0.1
	 */
	@Override
	public boolean downLoadCusInfoBatchCreateFile(String curDate) {
		boolean result = false;
		// 下载文件个数
		int downNum = 0;
		logger.info("批量客户建档结果下载开始，下载批量客户建档结果文件路径：" + baiduTranFilePath + curDate);
		try {
			CusIndivCreatesProInfoVO cusIndivCreatesProInfo = new CusIndivCreatesProInfoVO();
			// 状态 0 未处理
			cusIndivCreatesProInfo.setState(BdLoanConstant.NO_0);
			// 交易日期
			cusIndivCreatesProInfo.setTxnDt(curDate);
			// 通过状态查询客户建档结果过程信息
			List<CusIndivCreatesProInfoVO> cusCreProInfoList = cusIndivCreatesProInfoService.queryByState(cusIndivCreatesProInfo);
			// 远程文件路径
			String remotePath = "";
			// 远程文件名称
			String fileName = "";
			// 客户建档结果过程信息不为空
			if (Objects.nonNull(cusCreProInfoList) && !cusCreProInfoList.isEmpty()) {
				for (CusIndivCreatesProInfoVO cusIndivCreatesProInfoVO : cusCreProInfoList) {
					// 文件路径
					String ocmFlpth = cusIndivCreatesProInfoVO.getOcmFlpth();
					int index = ocmFlpth.lastIndexOf("/");
					// 远程文件路径
					remotePath = ocmFlpth.substring(0, index) + File.separator;
					// 远程文件名称
					fileName = ocmFlpth.substring(index + 1, ocmFlpth.length());
					// 文件名称
					boolean fileDownResult = downFile(remotePath, fileName);
					if (fileDownResult) {
						// 状态 1 下载文件到本地
						cusIndivCreatesProInfoVO.setState(BdLoanConstant.YES_1);
						// 最近修改时间
						cusIndivCreatesProInfoVO.setLastModifyTime(DateTool.getCurrentDateTime());
						int num = cusIndivCreatesProInfoService.updateByPk(cusIndivCreatesProInfoVO);
						if (num != -1) {
							downNum++;
						}
					}
				}
			}
			if (downNum > 0) {
				result = true;
			}
			// 校验客户建档信息是否存在
			if (!result) {
				result = checkBatchCreateFile(curDate);
			}
		} catch (Exception e) {
			e.printStackTrace();
			String tableInfo = "cus_indiv";
			String errorMsg = "批量客户建档结果下载出现异常";
			String remark = "批量客户建档结果下载开始，异常信息：" + e.getMessage();
			addErrorInfo(tableInfo, MonAlrmLvlEnum.SERIOUS.getEnname(), errorMsg, remark);
			logger.error(remark);
		}
		logger.info("批量客户建档结果下载结束，下载批量客户建档结果文件路径：" + baiduTranFilePath + "，处理结果[" + result + "]");
		return result;
	}

	/**
	 * 
	 * 是否初始化批量客户建档信息、批量客户建档结果信息 <br>
	 * 0.1:ludayong:2019年5月20日 下午10:25:20:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年5月20日 下午10:25:20
	 * @date 2019年5月20日 下午10:25:20
	 * @version 0.1
	 */
	@Override
	public boolean isInitCusInfoBatchCreateInfo(String curDate) {
		boolean result = false;
		logger.info("初始化批量客户建档信息、批量客户建档结果信息查询开始");
		try {
			CusIndivCreatesProInfoVO cusIndivCreatesProInfo = new CusIndivCreatesProInfoVO();
			// 状态 1 下载文件到本地
			cusIndivCreatesProInfo.setState(BdLoanConstant.YES_1);
			// 交易日期
			cusIndivCreatesProInfo.setTxnDt(curDate);
			// 通过状态查询客户建档结果过程信息
			List<CusIndivCreatesProInfoVO> cusCreProInfoList = cusIndivCreatesProInfoService.queryByState(cusIndivCreatesProInfo);
			// 客户建档结果过程信息不为空
			if (Objects.nonNull(cusCreProInfoList) && !cusCreProInfoList.isEmpty()) {
				result = true;
			}
			// 校验客户建档信息是否存在
			if (!result) {
				result = checkBatchCreateFile(curDate);
			}
		} catch (Exception e) {
			e.printStackTrace();
			String tableInfo = "cus_indiv";
			String errorMsg = "初始化批量客户建档信息、批量客户建档结果信息查询出现异常";
			String remark = "初始化批量客户建档信息、批量客户建档结果信息查询，异常信息：" + e.getMessage();
			addErrorInfo(tableInfo, MonAlrmLvlEnum.SERIOUS.getEnname(), errorMsg, remark);
			logger.error(remark);
		}
		logger.info("初始化批量客户建档信息、批量客户建档结果信息查询结束" + "，处理结果[" + result + "]");
		return result;
	}

	/**
	 * 
	 * 初始化批量客户建档信息、批量客户建档结果信息后处理 <br>
	 * 0.1:ludayong:2019年5月20日 下午10:25:20:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年5月20日 下午10:25:20
	 * @date 2019年5月20日 下午10:25:20
	 * @version 0.1
	 */
	public boolean initCusInfoBatchCreateInfoHandle(String curDate) {
		boolean result = false;
		logger.info("初始化批量客户建档信息、批量客户建档结果信息后处理，更新处理状态开始");

		// 更新数据数量
		int udpNum = 0;
		try {
			CusIndivCreatesProInfoVO cusIndivCreatesProInfo = new CusIndivCreatesProInfoVO();
			// 状态
			cusIndivCreatesProInfo.setState(BdLoanConstant.YES_1);
			// 交易日期
			cusIndivCreatesProInfo.setTxnDt(curDate);
			// 通过状态查询客户建档结果过程信息
			List<CusIndivCreatesProInfoVO> cusCreProInfoList = cusIndivCreatesProInfoService.queryByState(cusIndivCreatesProInfo);
			// 客户建档结果过程信息不为空
			if (Objects.nonNull(cusCreProInfoList) && !cusCreProInfoList.isEmpty()) {
				for (CusIndivCreatesProInfoVO cusIndivCreatesProInfoVO : cusCreProInfoList) {
					// 状态 2 已初始化到临时表
					cusIndivCreatesProInfoVO.setState(BdLoanConstant.YES_2);
					// 最近修改时间
					cusIndivCreatesProInfoVO.setLastModifyTime(DateTool.getCurrentDateTime());
					int num = cusIndivCreatesProInfoService.updateByPk(cusIndivCreatesProInfoVO);
					if (num != -1) {
						udpNum++;
					}
				}
			}
			if (udpNum > 0) {
				result = true;
			}
			// 校验客户建档信息是否存在
			if (!result) {
				result = checkBatchCreateFile(curDate);
			}
		} catch (Exception e) {
			e.printStackTrace();
			String tableInfo = "cus_indiv";
			String errorMsg = "初始化批量客户建档信息、批量客户建档结果信息后处理出现异常";
			String remark = "初始化批量客户建档信息、批量客户建档结果信息后处理，异常信息：" + e.getMessage();
			addErrorInfo(tableInfo, MonAlrmLvlEnum.SERIOUS.getEnname(), errorMsg, remark);
			logger.error(remark);
		}
		logger.info("初始化批量客户建档信息、批量客户建档结果信息后处理，更新处理状态结束，处理结果[" + result + "]");
		return result;
	}

	/**
	 * 
	 * 校验客户建档信息是否存在 <br>
	 * 0.1:ludayong:2019年5月20日 下午3:59:51:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年5月20日 下午3:59:51
	 * @date 2019年5月20日 下午3:59:51
	 * @version 0.1
	 */
	@Override
	public boolean checkBatchCreateFile(String curDate) {
		logger.info("校验客户建档信息是否存在处理开始");
		// 是否成功
		boolean result = false;
		// 远程文件名称
		String fileName = "";
		// 文件个数
		int fileNum = 0;
		try {
			CusIndivCreatesProInfoVO cusIndivCreatesProInfo = new CusIndivCreatesProInfoVO();
			// 交易日期
			cusIndivCreatesProInfo.setTxnDt(curDate);
			// 通过状态查询客户建档结果过程信息
			List<CusIndivCreatesProInfoVO> cusCreProInfoList = cusIndivCreatesProInfoService.queryByTxnDt(cusIndivCreatesProInfo);
			// 客户建档结果过程信息不为空
			if (Objects.nonNull(cusCreProInfoList) && !cusCreProInfoList.isEmpty()) {
				for (CusIndivCreatesProInfoVO cusIndivCreatesProInfoVO : cusCreProInfoList) {
					// 文件路径
					String ocmFlpth = cusIndivCreatesProInfoVO.getOcmFlpth();
					int index = ocmFlpth.lastIndexOf("/");
					// 远程文件名称
					fileName = ocmFlpth.substring(index + 1, ocmFlpth.length());

					// 客户建档信息文件路径
					String filePath = baiduTranFilePath + fileName;
					// 客户建档信息文件
					File batchCreateFile = new File(filePath);
					if (batchCreateFile.exists()) {
						fileNum++;
					}
				}
			}
			if (fileNum > 0) {
				result = true;
			}
		} catch (Exception e) {
			e.printStackTrace();
			String tableInfo = "cus_indiv";
			String errorMsg = "校验客户建档信息是否存在出现异常";
			String remark = "校验客户建档信息是否存在出现异常，异常信息：" + e.getMessage();
			addErrorInfo(tableInfo, MonAlrmLvlEnum.SERIOUS.getEnname(), errorMsg, remark);
			logger.error(remark);
		}
		logger.info("校验客户建档信息是否存在处理结束，处理结果[" + result + "]");
		return result;
	}

	/**
	 * 
	 * 上传客户建档信息到对内SFTP文件服务器 <br>
	 * 0.1:ludayong:2019年5月20日 下午3:59:51:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年5月20日 下午3:59:51
	 * @date 2019年5月20日 下午3:59:51
	 * @version 0.1
	 */
	private boolean upFile(String fileName) throws Exception {
		// 连接对内SFTP文件服务器
		SFTPUtil sftpUtil = null;
		// 上传文件是否成功
		boolean result = false;
		try {
			// 上传客户建档信息到对内SFTP文件服务器
			logger.info("对内SFTP文件服务器信息：" + userName + " / " + password + " IP: " + ftpHost + " 端口号：" + ftpPort);
			sftpUtil = new SFTPUtil(userName, password, ftpHost, ftpPort);
			// 本地文件路径
			String localFilePath = baiduTranFilePath + fileName;
			logger.info("本地客户建档文件地址：" + localFilePath);
			result = sftpUtil.upFile(remoteUpBaiduTransferFilePath, fileName, localFilePath, true, false);
			logger.info("上传客户建档信息到对内SFTP文件服务器：" + remoteUpBaiduTransferFilePath + fileName + "，结果[" + result + "]");
		} catch (Exception e) {
			e.printStackTrace();
			String tableInfo = "cus_indiv";
			String errorMsg = "上传客户建档信息到对内SFTP文件服务器出现异常";
			String remark = "上传客户建档信息到对内SFTP文件服务器出现异常，异常信息：" + e.getMessage();
			addErrorInfo(tableInfo, MonAlrmLvlEnum.SERIOUS.getEnname(), errorMsg, remark);
			logger.error(remark);
		} finally {
			if (sftpUtil != null) {
				sftpUtil.closeSFTP();
			}
		}
		return result;
	}

	/**
	 * 
	 * 从对内SFTP文件服务器下载客户建档结果信息<br>
	 * 0.1:ludayong:2019年5月20日 下午3:59:51:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年5月20日 下午3:59:51
	 * @date 2019年5月20日 下午3:59:51
	 * @version 0.1
	 */
	private boolean downFile(String remotePath, String fileName) throws Exception {
		// 连接对内SFTP文件服务器
		SFTPUtil sftpUtil = null;
		// 下载文件是否成功
		boolean result = false;
		try {
			// 从对内SFTP文件服务器下载客户建档结果信息
			logger.info("对内SFTP文件服务器信息：" + userName + " / " + password + " IP: " + ftpHost + " 端口号：" + ftpPort);
			sftpUtil = new SFTPUtil(userName, password, ftpHost, ftpPort);
			// 下载文件
			result = sftpUtil.downFile(sftpUtil, remotePath, fileName, baiduTranFilePath, fileName, false);
			logger.info("从对内SFTP文件服务器下载客户建档结果信息：" + remoteUpBaiduTransferFilePath + fileName + "，结果[" + result + "]");
		} catch (Exception e) {
			e.printStackTrace();
			String tableInfo = "cus_indiv";
			String errorMsg = "对内SFTP文件服务器下载客户建档结果信息出现异常";
			String remark = "对内SFTP文件服务器下载客户建档结果信息出现异常，异常信息：" + e.getMessage();
			addErrorInfo(tableInfo, MonAlrmLvlEnum.SERIOUS.getEnname(), errorMsg, remark);
			logger.error(remark);
		} finally {
			if (sftpUtil != null) {
				sftpUtil.closeSFTP();
			}
		}
		return result;
	}

	/**
	 * 
	 * 记录异常信息 <br>
	 * 0.1:ludayong:2019年5月7日 上午11:31:23:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年5月7日 上午11:31:23
	 * @date 2019年5月7日 上午11:31:23
	 * @version 0.1
	 */
	private void addErrorInfo(String tableName, String errorType, String errorMsg, String remark) {
		AccoutErroTempVO accoutErroTempVO = new AccoutErroTempVO();
		// 表名
		accoutErroTempVO.setTableName(tableName);
		// 错误级别
		accoutErroTempVO.setErroType(errorType);
		// 错误信息
		accoutErroTempVO.setErroMsg(errorMsg);
		// 备注
		accoutErroTempVO.setRemark(remark);
		// 创建时间
		accoutErroTempVO.setCreateData(DateTool.getCurrentDateTime());
		// 修改时间
		accoutErroTempVO.setLastModifyTime(DateTool.getCurrentDateTime());
		// 记录异常信息
		accoutErroTempService.insert(accoutErroTempVO);
	}
}
